home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / share / autoconf / m4sugar / m4sugar.m4 < prev    next >
Text File  |  2006-04-25  |  54KB  |  1,768 lines
  1. divert(-1)#                                                  -*- Autoconf -*-
  2. # This file is part of Autoconf.
  3. # Base M4 layer.
  4. # Requires GNU M4.
  5. #
  6. # Copyright (C) 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
  7. # Inc.
  8. #
  9. # This program is free software; you can redistribute it and/or modify
  10. # it under the terms of the GNU General Public License as published by
  11. # the Free Software Foundation; either version 2, or (at your option)
  12. # any later version.
  13. #
  14. # This program is distributed in the hope that it will be useful,
  15. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17. # GNU General Public License for more details.
  18. #
  19. # You should have received a copy of the GNU General Public License
  20. # along with this program; if not, write to the Free Software
  21. # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  22. # 02111-1307, USA.
  23. #
  24. # As a special exception, the Free Software Foundation gives unlimited
  25. # permission to copy, distribute and modify the configure scripts that
  26. # are the output of Autoconf.  You need not follow the terms of the GNU
  27. # General Public License when using or distributing such scripts, even
  28. # though portions of the text of Autoconf appear in them.  The GNU
  29. # General Public License (GPL) does govern all other use of the material
  30. # that constitutes the Autoconf program.
  31. #
  32. # Certain portions of the Autoconf source text are designed to be copied
  33. # (in certain cases, depending on the input) into the output of
  34. # Autoconf.  We call these the "data" portions.  The rest of the Autoconf
  35. # source text consists of comments plus executable code that decides which
  36. # of the data portions to output in any given case.  We call these
  37. # comments and executable code the "non-data" portions.  Autoconf never
  38. # copies any of the non-data portions into its output.
  39. #
  40. # This special exception to the GPL applies to versions of Autoconf
  41. # released by the Free Software Foundation.  When you make and
  42. # distribute a modified version of Autoconf, you may extend this special
  43. # exception to the GPL to apply to your modified version as well, *unless*
  44. # your modified version has the potential to copy into its output some
  45. # of the text that was the non-data portion of the version that you started
  46. # with.  (In other words, unless your change moves or copies text from
  47. # the non-data portions to the data portions.)  If your modification has
  48. # such potential, you must delete any notice of this special exception
  49. # to the GPL from your modified version.
  50. #
  51. # Written by Akim Demaille.
  52. #
  53.  
  54. # Set the quotes, whatever the current quoting system.
  55. changequote()
  56. changequote([, ])
  57.  
  58. # Some old m4's don't support m4exit.  But they provide
  59. # equivalent functionality by core dumping because of the
  60. # long macros we define.
  61. ifdef([__gnu__], ,
  62. [errprint(M4sugar requires GNU M4. Install it before installing M4sugar or
  63. set the M4 environment variable to its path name.)
  64. m4exit(2)])
  65.  
  66.  
  67. ## ------------------------------- ##
  68. ## 1. Simulate --prefix-builtins.  ##
  69. ## ------------------------------- ##
  70.  
  71. # m4_define
  72. # m4_defn
  73. # m4_undefine
  74. define([m4_define],   defn([define]))
  75. define([m4_defn],     defn([defn]))
  76. define([m4_undefine], defn([undefine]))
  77.  
  78. m4_undefine([define])
  79. m4_undefine([defn])
  80. m4_undefine([undefine])
  81.  
  82.  
  83. # m4_copy(SRC, DST)
  84. # -----------------
  85. # Define DST as the definition of SRC.
  86. # What's the difference between:
  87. # 1. m4_copy([from], [to])
  88. # 2. m4_define([from], [to($@)])
  89. # Well, obviously 1 is more expansive in space.  Maybe 2 is more expansive
  90. # in time, but because of the space cost of 1, it's not that obvious.
  91. # Nevertheless, one huge difference is the handling of `$0'.  If `from'
  92. # uses `$0', then with 1, `to''s `$0' is `to', while it is `from' in 2.
  93. # The user will certainly prefer see `from'.
  94. m4_define([m4_copy],
  95. [m4_define([$2], m4_defn([$1]))])
  96.  
  97.  
  98. # m4_rename(SRC, DST)
  99. # -------------------
  100. # Rename the macro SRC as DST.
  101. m4_define([m4_rename],
  102. [m4_copy([$1], [$2])m4_undefine([$1])])
  103.  
  104.  
  105. # m4_rename_m4(MACRO-NAME)
  106. # ------------------------
  107. # Rename MACRO-NAME as m4_MACRO-NAME.
  108. m4_define([m4_rename_m4],
  109. [m4_rename([$1], [m4_$1])])
  110.  
  111.  
  112. # m4_copy_unm4(m4_MACRO-NAME)
  113. # ---------------------------
  114. # Copy m4_MACRO-NAME as MACRO-NAME.
  115. m4_define([m4_copy_unm4],
  116. [m4_copy([$1], m4_bpatsubst([$1], [^m4_\(.*\)], [[\1]]))])
  117.  
  118.  
  119. # Some m4 internals have names colliding with tokens we might use.
  120. # Rename them a` la `m4 --prefix-builtins'.
  121. m4_rename_m4([builtin])
  122. m4_rename_m4([changecom])
  123. m4_rename_m4([changequote])
  124. m4_rename_m4([debugfile])
  125. m4_rename_m4([debugmode])
  126. m4_rename_m4([decr])
  127. m4_undefine([divert])
  128. m4_rename_m4([divnum])
  129. m4_rename_m4([dumpdef])
  130. m4_rename_m4([errprint])
  131. m4_rename_m4([esyscmd])
  132. m4_rename_m4([eval])
  133. m4_rename_m4([format])
  134. m4_rename_m4([ifdef])
  135. m4_rename([ifelse], [m4_if])
  136. m4_rename_m4([include])
  137. m4_rename_m4([incr])
  138. m4_rename_m4([index])
  139. m4_rename_m4([indir])
  140. m4_rename_m4([len])
  141. m4_rename([m4exit], [m4_exit])
  142. m4_rename([m4wrap], [m4_wrap])
  143. m4_rename_m4([maketemp])
  144. m4_rename([patsubst], [m4_bpatsubst])
  145. m4_undefine([popdef])
  146. m4_rename_m4([pushdef])
  147. m4_rename([regexp], [m4_bregexp])
  148. m4_rename_m4([shift])
  149. m4_rename_m4([sinclude])
  150. m4_rename_m4([substr])
  151. m4_rename_m4([symbols])
  152. m4_rename_m4([syscmd])
  153. m4_rename_m4([sysval])
  154. m4_rename_m4([traceoff])
  155. m4_rename_m4([traceon])
  156. m4_rename_m4([translit])
  157. m4_undefine([undivert])
  158.  
  159.  
  160. ## ------------------- ##
  161. ## 2. Error messages.  ##
  162. ## ------------------- ##
  163.  
  164.  
  165. # m4_location
  166. # -----------
  167. m4_define([m4_location],
  168. [__file__:__line__])
  169.  
  170.  
  171. # m4_errprintn(MSG)
  172. # -----------------
  173. # Same as `errprint', but with the missing end of line.
  174. m4_define([m4_errprintn],
  175. [m4_errprint([$1
  176. ])])
  177.  
  178.  
  179. # m4_warning(MSG)
  180. # ---------------
  181. # Warn the user.
  182. m4_define([m4_warning],
  183. [m4_errprintn(m4_location[: warning: $1])])
  184.  
  185.  
  186. # m4_fatal(MSG, [EXIT-STATUS])
  187. # ----------------------------
  188. # Fatal the user.                                                      :)
  189. m4_define([m4_fatal],
  190. [m4_errprintn(m4_location[: error: $1])dnl
  191. m4_expansion_stack_dump()dnl
  192. m4_exit(m4_if([$2],, 1, [$2]))])
  193.  
  194.  
  195. # m4_assert(EXPRESSION, [EXIT-STATUS = 1])
  196. # ----------------------------------------
  197. # This macro ensures that EXPRESSION evaluates to true, and exits if
  198. # EXPRESSION evaluates to false.
  199. m4_define([m4_assert],
  200. [m4_if(m4_eval([$1]), 0,
  201.        [m4_fatal([assert failed: $1], [$2])])])
  202.  
  203.  
  204.  
  205. ## ------------- ##
  206. ## 3. Warnings.  ##
  207. ## ------------- ##
  208.  
  209.  
  210. # _m4_warn(CATEGORY, MESSAGE, STACK-TRACE)
  211. # ----------------------------------------
  212. # Report a MESSAGE to the user if the CATEGORY of warnings is enabled.
  213. # This is for traces only.
  214. # The STACK-TRACE is a \n-separated list of "LOCATION: MESSAGE".
  215. m4_define([_m4_warn], [])
  216.  
  217.  
  218. # m4_warn(CATEGORY, MESSAGE)
  219. # --------------------------
  220. # Report a MESSAGE to the user if the CATEGORY of warnings is enabled.
  221. m4_define([m4_warn],
  222. [_m4_warn([$1], [$2],
  223. m4_ifdef([m4_expansion_stack],
  224.          [m4_defn([m4_expansion_stack])
  225. m4_location[: the top level]]))dnl
  226. ])
  227.  
  228.  
  229.  
  230. ## ------------------- ##
  231. ## 4. File inclusion.  ##
  232. ## ------------------- ##
  233.  
  234.  
  235. # We also want to neutralize include (and sinclude for symmetry),
  236. # but we want to extend them slightly: warn when a file is included
  237. # several times.  This is in general a dangerous operation because
  238. # quite nobody quotes the first argument of m4_define.
  239. #
  240. # For instance in the following case:
  241. #   m4_define(foo, [bar])
  242. # then a second reading will turn into
  243. #   m4_define(bar, [bar])
  244. # which is certainly not what was meant.
  245.  
  246. # m4_include_unique(FILE)
  247. # -----------------------
  248. # Declare that the FILE was loading; and warn if it has already
  249. # been included.
  250. m4_define([m4_include_unique],
  251. [m4_ifdef([m4_include($1)],
  252.       [m4_warn([syntax], [file `$1' included several times])])dnl
  253. m4_define([m4_include($1)])])
  254.  
  255.  
  256. # m4_include(FILE)
  257. # ----------------
  258. # As the builtin include, but warns against multiple inclusions.
  259. m4_define([m4_include],
  260. [m4_include_unique([$1])dnl
  261. m4_builtin([include], [$1])])
  262.  
  263.  
  264. # m4_sinclude(FILE)
  265. # -----------------
  266. # As the builtin sinclude, but warns against multiple inclusions.
  267. m4_define([m4_sinclude],
  268. [m4_include_unique([$1])dnl
  269. m4_builtin([sinclude], [$1])])
  270.  
  271.  
  272.  
  273. ## ------------------------------------ ##
  274. ## 5. Additional branching constructs.  ##
  275. ## ------------------------------------ ##
  276.  
  277. # Both `m4_ifval' and `m4_ifset' tests against the empty string.  The
  278. # difference is that `m4_ifset' is specialized on macros.
  279. #
  280. # In case of arguments of macros, eg $[1], it makes little difference.
  281. # In the case of a macro `FOO', you don't want to check `m4_ifval(FOO,
  282. # TRUE)', because if `FOO' expands with commas, there is a shifting of
  283. # the arguments.  So you want to run `m4_ifval([FOO])', but then you just
  284. # compare the *string* `FOO' against `', which, of course fails.
  285. #
  286. # So you want a variation of `m4_ifset' that expects a macro name as $[1].
  287. # If this macro is both defined and defined to a non empty value, then
  288. # it runs TRUE etc.
  289.  
  290.  
  291. # m4_ifval(COND, [IF-TRUE], [IF-FALSE])
  292. # -------------------------------------
  293. # If COND is not the empty string, expand IF-TRUE, otherwise IF-FALSE.
  294. # Comparable to m4_ifdef.
  295. m4_define([m4_ifval],
  296. [m4_if([$1], [], [$3], [$2])])
  297.  
  298.  
  299. # m4_n(TEXT)
  300. # ----------
  301. # If TEXT is not empty, return TEXT and a new line, otherwise nothing.
  302. m4_define([m4_n],
  303. [m4_if([$1],
  304.        [], [],
  305.        [$1
  306. ])])
  307.  
  308.  
  309. # m4_ifvaln(COND, [IF-TRUE], [IF-FALSE])
  310. # --------------------------------------
  311. # Same as `m4_ifval', but add an extra newline to IF-TRUE or IF-FALSE
  312. # unless that argument is empty.
  313. m4_define([m4_ifvaln],
  314. [m4_if([$1],
  315.        [],   [m4_n([$3])],
  316.          [m4_n([$2])])])
  317.  
  318.  
  319. # m4_ifset(MACRO, [IF-TRUE], [IF-FALSE])
  320. # --------------------------------------
  321. # If MACRO has no definition, or of its definition is the empty string,
  322. # expand IF-FALSE, otherwise IF-TRUE.
  323. m4_define([m4_ifset],
  324. [m4_ifdef([$1],
  325.       [m4_if(m4_defn([$1]), [], [$3], [$2])],
  326.       [$3])])
  327.  
  328.  
  329. # m4_ifndef(NAME, [IF-NOT-DEFINED], [IF-DEFINED])
  330. # -----------------------------------------------
  331. m4_define([m4_ifndef],
  332. [m4_ifdef([$1], [$3], [$2])])
  333.  
  334.  
  335. # m4_case(SWITCH, VAL1, IF-VAL1, VAL2, IF-VAL2, ..., DEFAULT)
  336. # -----------------------------------------------------------
  337. # m4 equivalent of
  338. # switch (SWITCH)
  339. # {
  340. #   case VAL1:
  341. #     IF-VAL1;
  342. #     break;
  343. #   case VAL2:
  344. #     IF-VAL2;
  345. #     break;
  346. #   ...
  347. #   default:
  348. #     DEFAULT;
  349. #     break;
  350. # }.
  351. # All the values are optional, and the macro is robust to active
  352. # symbols properly quoted.
  353. m4_define([m4_case],
  354. [m4_if([$#], 0, [],
  355.        [$#], 1, [],
  356.        [$#], 2, [$2],
  357.        [$1], [$2], [$3],
  358.        [$0([$1], m4_shiftn(3, $@))])])
  359.  
  360.  
  361. # m4_bmatch(SWITCH, RE1, VAL1, RE2, VAL2, ..., DEFAULT)
  362. # -----------------------------------------------------
  363. # m4 equivalent of
  364. #
  365. # if (SWITCH =~ RE1)
  366. #   VAL1;
  367. # elif (SWITCH =~ RE2)
  368. #   VAL2;
  369. # elif ...
  370. #   ...
  371. # else
  372. #   DEFAULT
  373. #
  374. # All the values are optional, and the macro is robust to active symbols
  375. # properly quoted.
  376. m4_define([m4_bmatch],
  377. [m4_if([$#], 0, [],
  378.        [$#], 1, [],
  379.        [$#], 2, [$2],
  380.        [m4_if(m4_bregexp([$1], [$2]), -1, [$0([$1], m4_shiftn(3, $@))],
  381.           [$3])])])
  382.  
  383.  
  384. # m4_map(MACRO, LIST)
  385. # -------------------
  386. # Invoke MACRO($1), MACRO($2) etc. where $1, $2... are the elements
  387. # of LIST (which can be lists themselves, for multiple arguments MACROs).
  388. m4_define([m4_fst], [$1])
  389. m4_define([m4_map],
  390. [m4_if([$2], [[]], [],
  391.        [$1(m4_fst($2))[]dnl
  392. m4_map([$1], m4_cdr($2))])])
  393.  
  394.  
  395. # m4_map_sep(MACRO, SEPARATOR, LIST)
  396. # ----------------------------------
  397. # Invoke MACRO($1), SEPARATOR, MACRO($2), ..., MACRO($N) where $1, $2... $N
  398. # are the elements of LIST (which can be lists themselves, for multiple
  399. # arguments MACROs).
  400. m4_define([m4_map_sep],
  401. [m4_if([$3], [[]], [],
  402.        [$1(m4_fst($3))[]dnl
  403. m4_if(m4_cdr($3),
  404.       [[]], [],
  405.       [$2])[]dnl
  406. m4_map_sep([$1], [$2], m4_cdr($3))])])
  407.  
  408.  
  409. ## ---------------------------------------- ##
  410. ## 6. Enhanced version of some primitives.  ##
  411. ## ---------------------------------------- ##
  412.  
  413. # m4_patsubsts(STRING, RE1, SUBST1, RE2, SUBST2, ...)
  414. # ---------------------------------------------------
  415. # m4 equivalent of
  416. #
  417. #   $_ = STRING;
  418. #   s/RE1/SUBST1/g;
  419. #   s/RE2/SUBST2/g;
  420. #   ...
  421. #
  422. # All the values are optional, and the macro is robust to active symbols
  423. # properly quoted.
  424. #
  425. # I would have liked to name this macro `m4_patsubst', unfortunately,
  426. # due to quotation problems, I need to double quote $1 below, therefore
  427. # the anchors are broken :(  I can't let users be trapped by that.
  428. m4_define([m4_bpatsubsts],
  429. [m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])],
  430.        [$#], 1, [m4_fatal([$0: too few arguments: $#: $1])],
  431.        [$#], 2, [m4_builtin([patsubst], $@)],
  432.        [$0(m4_builtin([patsubst], [[$1]], [$2], [$3]),
  433.        m4_shiftn(3, $@))])])
  434.  
  435.  
  436.  
  437. # m4_do(STRING, ...)
  438. # ------------------
  439. # This macro invokes all its arguments (in sequence, of course).  It is
  440. # useful for making your macros more structured and readable by dropping
  441. # unnecessary dnl's and have the macros indented properly.
  442. m4_define([m4_do],
  443. [m4_if($#, 0, [],
  444.        $#, 1, [$1],
  445.        [$1[]m4_do(m4_shift($@))])])
  446.  
  447.  
  448. # m4_define_default(MACRO, VALUE)
  449. # -------------------------------
  450. # If MACRO is undefined, set it to VALUE.
  451. m4_define([m4_define_default],
  452. [m4_ifndef([$1], [m4_define($@)])])
  453.  
  454.  
  455. # m4_default(EXP1, EXP2)
  456. # ----------------------
  457. # Returns EXP1 if non empty, otherwise EXP2.
  458. m4_define([m4_default],
  459. [m4_ifval([$1], [$1], [$2])])
  460.  
  461.  
  462. # m4_defn(NAME)
  463. # -------------
  464. # Unlike to the original, don't tolerate popping something which is
  465. # undefined.
  466. m4_define([m4_defn],
  467. [m4_ifndef([$1],
  468.        [m4_fatal([$0: undefined macro: $1])])dnl
  469. m4_builtin([defn], $@)])
  470.  
  471.  
  472. # _m4_dumpdefs_up(NAME)
  473. # ---------------------
  474. m4_define([_m4_dumpdefs_up],
  475. [m4_ifdef([$1],
  476.       [m4_pushdef([_m4_dumpdefs], m4_defn([$1]))dnl
  477. m4_dumpdef([$1])dnl
  478. m4_popdef([$1])dnl
  479. _m4_dumpdefs_up([$1])])])
  480.  
  481.  
  482. # _m4_dumpdefs_down(NAME)
  483. # -----------------------
  484. m4_define([_m4_dumpdefs_down],
  485. [m4_ifdef([_m4_dumpdefs],
  486.       [m4_pushdef([$1], m4_defn([_m4_dumpdefs]))dnl
  487. m4_popdef([_m4_dumpdefs])dnl
  488. _m4_dumpdefs_down([$1])])])
  489.  
  490.  
  491. # m4_dumpdefs(NAME)
  492. # -----------------
  493. # Similar to `m4_dumpdef(NAME)', but if NAME was m4_pushdef'ed, display its
  494. # value stack (most recent displayed first).
  495. m4_define([m4_dumpdefs],
  496. [_m4_dumpdefs_up([$1])dnl
  497. _m4_dumpdefs_down([$1])])
  498.  
  499.  
  500. # m4_popdef(NAME)
  501. # ---------------
  502. # Unlike to the original, don't tolerate popping something which is
  503. # undefined.
  504. m4_define([m4_popdef],
  505. [m4_ifndef([$1],
  506.        [m4_fatal([$0: undefined macro: $1])])dnl
  507. m4_builtin([popdef], $@)])
  508.  
  509.  
  510. # m4_quote(ARGS)
  511. # --------------
  512. # Return ARGS as a single arguments.
  513. #
  514. # It is important to realize the difference between `m4_quote(exp)' and
  515. # `[exp]': in the first case you obtain the quoted *result* of the
  516. # expansion of EXP, while in the latter you just obtain the string
  517. # `exp'.
  518. m4_define([m4_quote],  [[$*]])
  519. m4_define([m4_dquote],  [[$@]])
  520.  
  521.  
  522. # m4_noquote(STRING)
  523. # ------------------
  524. # Return the result of ignoring all quotes in STRING and invoking the
  525. # macros it contains.  Amongst other things useful for enabling macro
  526. # invocations inside strings with [] blocks (for instance regexps and
  527. # help-strings).
  528. m4_define([m4_noquote],
  529. [m4_changequote(-=<{,}>=-)$1-=<{}>=-m4_changequote([,])])
  530.  
  531.  
  532. # m4_shiftn(N, ...)
  533. # -----------------
  534. # Returns ... shifted N times.  Useful for recursive "varargs" constructs.
  535. m4_define([m4_shiftn],
  536. [m4_assert(($1 >= 0) && ($# > $1))dnl
  537. _m4_shiftn($@)])
  538.  
  539. m4_define([_m4_shiftn],
  540. [m4_if([$1], 0,
  541.        [m4_shift($@)],
  542.        [_m4_shiftn(m4_eval([$1]-1), m4_shift(m4_shift($@)))])])
  543.  
  544.  
  545. # m4_undefine(NAME)
  546. # -----------------
  547. # Unlike to the original, don't tolerate undefining something which is
  548. # undefined.
  549. m4_define([m4_undefine],
  550. [m4_ifndef([$1],
  551.        [m4_fatal([$0: undefined macro: $1])])dnl
  552. m4_builtin([undefine], $@)])
  553.  
  554.  
  555. ## -------------------------- ##
  556. ## 7. Implementing m4 loops.  ##
  557. ## -------------------------- ##
  558.  
  559.  
  560. # m4_for(VARIABLE, FIRST, LAST, [STEP = +/-1], EXPRESSION)
  561. # --------------------------------------------------------
  562. # Expand EXPRESSION defining VARIABLE to FROM, FROM + 1, ..., TO.
  563. # Both limits are included, and bounds are checked for consistency.
  564. m4_define([m4_for],
  565. [m4_case(m4_sign(m4_eval($3 - $2)),
  566.      1, [m4_assert(m4_sign(m4_default($4, 1)) == 1)],
  567.     -1, [m4_assert(m4_sign(m4_default($4, -1)) == -1)])dnl
  568. m4_pushdef([$1], [$2])dnl
  569. m4_if(m4_eval([$3 > $2]), 1,
  570.       [_m4_for([$1], [$3], m4_default([$4], 1), [$5])],
  571.       [_m4_for([$1], [$3], m4_default([$4], -1), [$5])])dnl
  572. m4_popdef([$1])])
  573.  
  574.  
  575. # _m4_for(VARIABLE, FIRST, LAST, STEP, EXPRESSION)
  576. # ------------------------------------------------
  577. # Core of the loop, no consistency checks.
  578. m4_define([_m4_for],
  579. [$4[]dnl
  580. m4_if($1, [$2], [],
  581.       [m4_define([$1], m4_eval($1+[$3]))_m4_for([$1], [$2], [$3], [$4])])])
  582.  
  583.  
  584. # Implementing `foreach' loops in m4 is much more tricky than it may
  585. # seem.  Actually, the example of a `foreach' loop in the m4
  586. # documentation is wrong: it does not quote the arguments properly,
  587. # which leads to undesirable expansions.
  588. #
  589. # The example in the documentation is:
  590. #
  591. # | # foreach(VAR, (LIST), STMT)
  592. # | m4_define([foreach],
  593. # |        [m4_pushdef([$1])_foreach([$1], [$2], [$3])m4_popdef([$1])])
  594. # | m4_define([_arg1], [$1])
  595. # | m4_define([_foreach],
  596. # |           [m4_if([$2], [()], ,
  597. # |             [m4_define([$1], _arg1$2)$3[]_foreach([$1],
  598. # |                                                        (shift$2),
  599. # |                                                        [$3])])])
  600. #
  601. # But then if you run
  602. #
  603. # | m4_define(a, 1)
  604. # | m4_define(b, 2)
  605. # | m4_define(c, 3)
  606. # | foreach([f], [([a], [(b], [c)])], [echo f
  607. # | ])
  608. #
  609. # it gives
  610. #
  611. #  => echo 1
  612. #  => echo (2,3)
  613. #
  614. # which is not what is expected.
  615. #
  616. # Of course the problem is that many quotes are missing.  So you add
  617. # plenty of quotes at random places, until you reach the expected
  618. # result.  Alternatively, if you are a quoting wizard, you directly
  619. # reach the following implementation (but if you really did, then
  620. # apply to the maintenance of m4sugar!).
  621. #
  622. # | # foreach(VAR, (LIST), STMT)
  623. # | m4_define([foreach], [m4_pushdef([$1])_foreach($@)m4_popdef([$1])])
  624. # | m4_define([_arg1], [[$1]])
  625. # | m4_define([_foreach],
  626. # |  [m4_if($2, [()], ,
  627. # |         [m4_define([$1], [_arg1$2])$3[]_foreach([$1],
  628. # |                                                 [(shift$2)],
  629. # |                                                 [$3])])])
  630. #
  631. # which this time answers
  632. #
  633. #  => echo a
  634. #  => echo (b
  635. #  => echo c)
  636. #
  637. # Bingo!
  638. #
  639. # Well, not quite.
  640. #
  641. # With a better look, you realize that the parens are more a pain than
  642. # a help: since anyway you need to quote properly the list, you end up
  643. # with always using an outermost pair of parens and an outermost pair
  644. # of quotes.  Rejecting the parens both eases the implementation, and
  645. # simplifies the use:
  646. #
  647. # | # foreach(VAR, (LIST), STMT)
  648. # | m4_define([foreach], [m4_pushdef([$1])_foreach($@)m4_popdef([$1])])
  649. # | m4_define([_arg1], [$1])
  650. # | m4_define([_foreach],
  651. # |  [m4_if($2, [], ,
  652. # |         [m4_define([$1], [_arg1($2)])$3[]_foreach([$1],
  653. # |                                                   [shift($2)],
  654. # |                                                   [$3])])])
  655. #
  656. #
  657. # Now, just replace the `$2' with `m4_quote($2)' in the outer `m4_if'
  658. # to improve robustness, and you come up with a quite satisfactory
  659. # implementation.
  660.  
  661.  
  662. # m4_foreach(VARIABLE, LIST, EXPRESSION)
  663. # --------------------------------------
  664. #
  665. # Expand EXPRESSION assigning each value of the LIST to VARIABLE.
  666. # LIST should have the form `item_1, item_2, ..., item_n', i.e. the
  667. # whole list must *quoted*.  Quote members too if you don't want them
  668. # to be expanded.
  669. #
  670. # This macro is robust to active symbols:
  671. #      | m4_define(active, [ACT, IVE])
  672. #      | m4_foreach(Var, [active, active], [-Var-])
  673. #     => -ACT--IVE--ACT--IVE-
  674. #
  675. #      | m4_foreach(Var, [[active], [active]], [-Var-])
  676. #     => -ACT, IVE--ACT, IVE-
  677. #
  678. #      | m4_foreach(Var, [[[active]], [[active]]], [-Var-])
  679. #     => -active--active-
  680. m4_define([m4_foreach],
  681. [m4_pushdef([$1])_m4_foreach($@)m4_popdef([$1])])
  682.  
  683. # Low level macros used to define m4_foreach.
  684. m4_define([m4_car], [[$1]])
  685. m4_define([m4_cdr], [m4_dquote(m4_shift($@))])
  686. m4_define([_m4_foreach],
  687. [m4_if([$2], [[]], [],
  688.        [m4_define([$1], m4_car($2))$3[]_m4_foreach([$1],
  689.                            m4_cdr($2),
  690.                            [$3])])])
  691.  
  692.  
  693.  
  694. ## --------------------------- ##
  695. ## 8. More diversion support.  ##
  696. ## --------------------------- ##
  697.  
  698.  
  699. # _m4_divert(DIVERSION-NAME or NUMBER)
  700. # ------------------------------------
  701. # If DIVERSION-NAME is the name of a diversion, return its number,
  702. # otherwise if is a NUMBER return it.
  703. m4_define([_m4_divert],
  704. [m4_ifdef([_m4_divert($1)],
  705.       [m4_indir([_m4_divert($1)])],
  706.       [$1])])
  707.  
  708. # KILL is only used to suppress output.
  709. m4_define([_m4_divert(KILL)],           -1)
  710.  
  711.  
  712. # m4_divert(DIVERSION-NAME)
  713. # -------------------------
  714. # Change the diversion stream to DIVERSION-NAME.
  715. m4_define([m4_divert],
  716. [m4_define([m4_divert_stack],
  717.        m4_location[: $0: $1]m4_ifdef([m4_divert_stack], [
  718. m4_defn([m4_divert_stack])]))dnl
  719. m4_builtin([divert], _m4_divert([$1]))dnl
  720. ])
  721.  
  722.  
  723. # m4_divert_push(DIVERSION-NAME)
  724. # ------------------------------
  725. # Change the diversion stream to DIVERSION-NAME, while stacking old values.
  726. m4_define([m4_divert_push],
  727. [m4_pushdef([m4_divert_stack],
  728.         m4_location[: $0: $1]m4_ifdef([m4_divert_stack], [
  729. m4_defn([m4_divert_stack])]))dnl
  730. m4_pushdef([_m4_divert_diversion], [$1])dnl
  731. m4_builtin([divert], _m4_divert(_m4_divert_diversion))dnl
  732. ])
  733.  
  734.  
  735. # m4_divert_pop([DIVERSION-NAME])
  736. # -------------------------------
  737. # Change the diversion stream to its previous value, unstacking it.
  738. # If specified, verify we left DIVERSION-NAME.
  739. m4_define([m4_divert_pop],
  740. [m4_ifval([$1],
  741.      [m4_if(_m4_divert([$1]), m4_divnum, [],
  742.         [m4_fatal([$0($1): diversion mismatch: ]
  743. m4_defn([m4_divert_stack]))])])dnl
  744. m4_popdef([_m4_divert_diversion])dnl
  745. dnl m4_ifndef([_m4_divert_diversion],
  746. dnl           [m4_fatal([too many m4_divert_pop])])dnl
  747. m4_builtin([divert],
  748.        m4_ifdef([_m4_divert_diversion],
  749.             [_m4_divert(_m4_divert_diversion)], -1))dnl
  750. m4_popdef([m4_divert_stack])dnl
  751. ])
  752.  
  753.  
  754. # m4_divert_text(DIVERSION-NAME, CONTENT)
  755. # ---------------------------------------
  756. # Output CONTENT into DIVERSION-NAME (which may be a number actually).
  757. # An end of line is appended for free to CONTENT.
  758. m4_define([m4_divert_text],
  759. [m4_divert_push([$1])dnl
  760. $2
  761. m4_divert_pop([$1])dnl
  762. ])
  763.  
  764.  
  765. # m4_divert_once(DIVERSION-NAME, CONTENT)
  766. # ---------------------------------------
  767. # Output once CONTENT into DIVERSION-NAME (which may be a number
  768. # actually).  An end of line is appended for free to CONTENT.
  769. m4_define([m4_divert_once],
  770. [m4_expand_once([m4_divert_text([$1], [$2])])])
  771.  
  772.  
  773. # m4_undivert(DIVERSION-NAME)
  774. # ---------------------------
  775. # Undivert DIVERSION-NAME.
  776. m4_define([m4_undivert],
  777. [m4_builtin([undivert], _m4_divert([$1]))])
  778.  
  779.  
  780. ## -------------------------------------------- ##
  781. ## 8. Defining macros with bells and whistles.  ##
  782. ## -------------------------------------------- ##
  783.  
  784. # `m4_defun' is basically `m4_define' but it equips the macro with the
  785. # needed machinery for `m4_require'.  A macro must be m4_defun'd if
  786. # either it is m4_require'd, or it m4_require's.
  787. #
  788. # Two things deserve attention and are detailed below:
  789. #  1. Implementation of m4_require
  790. #  2. Keeping track of the expansion stack
  791. #
  792. # 1. Implementation of m4_require
  793. # ===============================
  794. #
  795. # Of course m4_defun AC_PROVIDE's the macro, so that a macro which has
  796. # been expanded is not expanded again when m4_require'd, but the
  797. # difficult part is the proper expansion of macros when they are
  798. # m4_require'd.
  799. #
  800. # The implementation is based on two ideas, (i) using diversions to
  801. # prepare the expansion of the macro and its dependencies (by Franc,ois
  802. # Pinard), and (ii) expand the most recently m4_require'd macros _after_
  803. # the previous macros (by Axel Thimm).
  804. #
  805. #
  806. # The first idea: why using diversions?
  807. # -------------------------------------
  808. #
  809. # When a macro requires another, the other macro is expanded in new
  810. # diversion, GROW.  When the outer macro is fully expanded, we first
  811. # undivert the most nested diversions (GROW - 1...), and finally
  812. # undivert GROW.  To understand why we need several diversions,
  813. # consider the following example:
  814. #
  815. # | m4_defun([TEST1], [Test...REQUIRE([TEST2])1])
  816. # | m4_defun([TEST2], [Test...REQUIRE([TEST3])2])
  817. # | m4_defun([TEST3], [Test...3])
  818. #
  819. # Because m4_require is not required to be first in the outer macros, we
  820. # must keep the expansions of the various level of m4_require separated.
  821. # Right before executing the epilogue of TEST1, we have:
  822. #
  823. #       GROW - 2: Test...3
  824. #       GROW - 1: Test...2
  825. #       GROW:     Test...1
  826. #       BODY:
  827. #
  828. # Finally the epilogue of TEST1 undiverts GROW - 2, GROW - 1, and
  829. # GROW into the regular flow, BODY.
  830. #
  831. #       GROW - 2:
  832. #       GROW - 1:
  833. #       GROW:
  834. #       BODY:        Test...3; Test...2; Test...1
  835. #
  836. # (The semicolons are here for clarification, but of course are not
  837. # emitted.)  This is what Autoconf 2.0 (I think) to 2.13 (I'm sure)
  838. # implement.
  839. #
  840. #
  841. # The second idea: first required first out
  842. # -----------------------------------------
  843. #
  844. # The natural implementation of the idea above is buggy and produces
  845. # very surprising results in some situations.  Let's consider the
  846. # following example to explain the bug:
  847. #
  848. # | m4_defun([TEST1],  [REQUIRE([TEST2a])REQUIRE([TEST2b])])
  849. # | m4_defun([TEST2a], [])
  850. # | m4_defun([TEST2b], [REQUIRE([TEST3])])
  851. # | m4_defun([TEST3],  [REQUIRE([TEST2a])])
  852. # |
  853. # | AC_INIT
  854. # | TEST1
  855. #
  856. # The dependencies between the macros are:
  857. #
  858. #         3 --- 2b
  859. #        /        \              is m4_require'd by
  860. #           /          \       left -------------------- right
  861. #        2a ------------ 1
  862. #
  863. # If you strictly apply the rules given in the previous section you get:
  864. #
  865. #       GROW - 2: TEST3
  866. #       GROW - 1: TEST2a; TEST2b
  867. #       GROW:     TEST1
  868. #       BODY:
  869. #
  870. # (TEST2a, although required by TEST3 is not expanded in GROW - 3
  871. # because is has already been expanded before in GROW - 1, so it has
  872. # been AC_PROVIDE'd, so it is not expanded again) so when you undivert
  873. # the stack of diversions, you get:
  874. #
  875. #       GROW - 2:
  876. #       GROW - 1:
  877. #       GROW:
  878. #       BODY:        TEST3; TEST2a; TEST2b; TEST1
  879. #
  880. # i.e., TEST2a is expanded after TEST3 although the latter required the
  881. # former.
  882. #
  883. # Starting from 2.50, uses an implementation provided by Axel Thimm.
  884. # The idea is simple: the order in which macros are emitted must be the
  885. # same as the one in which macro are expanded.  (The bug above can
  886. # indeed be described as: a macro has been AC_PROVIDE'd, but it is
  887. # emitted after: the lack of correlation between emission and expansion
  888. # order is guilty).
  889. #
  890. # How to do that?  You keeping the stack of diversions to elaborate the
  891. # macros, but each time a macro is fully expanded, emit it immediately.
  892. #
  893. # In the example above, when TEST2a is expanded, but it's epilogue is
  894. # not run yet, you have:
  895. #
  896. #       GROW - 2:
  897. #       GROW - 1: TEST2a
  898. #       GROW:     Elaboration of TEST1
  899. #       BODY:
  900. #
  901. # The epilogue of TEST2a emits it immediately:
  902. #
  903. #       GROW - 2:
  904. #       GROW - 1:
  905. #       GROW:     Elaboration of TEST1
  906. #       BODY:     TEST2a
  907. #
  908. # TEST2b then requires TEST3, so right before the epilogue of TEST3, you
  909. # have:
  910. #
  911. #       GROW - 2: TEST3
  912. #       GROW - 1: Elaboration of TEST2b
  913. #       GROW:     Elaboration of TEST1
  914. #       BODY:      TEST2a
  915. #
  916. # The epilogue of TEST3 emits it:
  917. #
  918. #       GROW - 2:
  919. #       GROW - 1: Elaboration of TEST2b
  920. #       GROW:     Elaboration of TEST1
  921. #       BODY:     TEST2a; TEST3
  922. #
  923. # TEST2b is now completely expanded, and emitted:
  924. #
  925. #       GROW - 2:
  926. #       GROW - 1:
  927. #       GROW:     Elaboration of TEST1
  928. #       BODY:     TEST2a; TEST3; TEST2b
  929. #
  930. # and finally, TEST1 is finished and emitted:
  931. #
  932. #       GROW - 2:
  933. #       GROW - 1:
  934. #       GROW:
  935. #       BODY:     TEST2a; TEST3; TEST2b: TEST1
  936. #
  937. # The idea, is simple, but the implementation is a bit evolved.  If you
  938. # are like me, you will want to see the actual functioning of this
  939. # implementation to be convinced.  The next section gives the full
  940. # details.
  941. #
  942. #
  943. # The Axel Thimm implementation at work
  944. # -------------------------------------
  945. #
  946. # We consider the macros above, and this configure.ac:
  947. #
  948. #        AC_INIT
  949. #        TEST1
  950. #
  951. # You should keep the definitions of _m4_defun_pro, _m4_defun_epi, and
  952. # m4_require at hand to follow the steps.
  953. #
  954. # This implements tries not to assume that of the current diversion is
  955. # BODY, so as soon as a macro (m4_defun'd) is expanded, we first
  956. # record the current diversion under the name _m4_divert_dump (denoted
  957. # DUMP below for short).  This introduces an important difference with
  958. # the previous versions of Autoconf: you cannot use m4_require if you
  959. # were not inside an m4_defun'd macro, and especially, you cannot
  960. # m4_require directly from the top level.
  961. #
  962. # We have not tried to simulate the old behavior (better yet, we
  963. # diagnose it), because it is too dangerous: a macro m4_require'd from
  964. # the top level is expanded before the body of `configure', i.e., before
  965. # any other test was run.  I let you imagine the result of requiring
  966. # AC_STDC_HEADERS for instance, before AC_PROG_CC was actually run....
  967. #
  968. # After AC_INIT was run, the current diversion is BODY.
  969. # * AC_INIT was run
  970. #   DUMP:                undefined
  971. #   diversion stack:     BODY |-
  972. #
  973. # * TEST1 is expanded
  974. # The prologue of TEST1 sets AC_DIVERSION_DUMP, which is the diversion
  975. # where the current elaboration will be dumped, to the current
  976. # diversion.  It also m4_divert_push to GROW, where the full
  977. # expansion of TEST1 and its dependencies will be elaborated.
  978. #   DUMP:       BODY
  979. #   BODY:       empty
  980. #   diversions: GROW, BODY |-
  981. #
  982. # * TEST1 requires TEST2a: prologue
  983. # m4_require m4_divert_pushes another temporary diversion GROW - 1 (in
  984. # fact, the diversion whose number is one less than the current
  985. # diversion), and expands TEST2a in there.
  986. #   DUMP:       BODY
  987. #   BODY:       empty
  988. #   diversions: GROW-1, GROW, BODY |-
  989. #
  990. # * TEST2a is expanded.
  991. # Its prologue pushes the current diversion again.
  992. #   DUMP:       BODY
  993. #   BODY:       empty
  994. #   diversions: GROW - 1, GROW - 1, GROW, BODY |-
  995. # It is expanded in GROW - 1, and GROW - 1 is popped by the epilogue
  996. # of TEST2a.
  997. #   DUMP:        BODY
  998. #   BODY:        nothing
  999. #   GROW - 1:    TEST2a
  1000. #   diversions:  GROW - 1, GROW, BODY |-
  1001. #
  1002. # * TEST1 requires TEST2a: epilogue
  1003. # The content of the current diversion is appended to DUMP (and removed
  1004. # from the current diversion).  A diversion is popped.
  1005. #   DUMP:       BODY
  1006. #   BODY:       TEST2a
  1007. #   diversions: GROW, BODY |-
  1008. #
  1009. # * TEST1 requires TEST2b: prologue
  1010. # m4_require pushes GROW - 1 and expands TEST2b.
  1011. #   DUMP:       BODY
  1012. #   BODY:       TEST2a
  1013. #   diversions: GROW - 1, GROW, BODY |-
  1014. #
  1015. # * TEST2b is expanded.
  1016. # Its prologue pushes the current diversion again.
  1017. #   DUMP:       BODY
  1018. #   BODY:       TEST2a
  1019. #   diversions: GROW - 1, GROW - 1, GROW, BODY |-
  1020. # The body is expanded here.
  1021. #
  1022. # * TEST2b requires TEST3: prologue
  1023. # m4_require pushes GROW - 2 and expands TEST3.
  1024. #   DUMP:       BODY
  1025. #   BODY:       TEST2a
  1026. #   diversions: GROW - 2, GROW - 1, GROW - 1, GROW, BODY |-
  1027. #
  1028. # * TEST3 is expanded.
  1029. # Its prologue pushes the current diversion again.
  1030. #   DUMP:       BODY
  1031. #   BODY:       TEST2a
  1032. #   diversions: GROW-2, GROW-2, GROW-1, GROW-1, GROW, BODY |-
  1033. # TEST3 requires TEST2a, but TEST2a has already been AC_PROVIDE'd, so
  1034. # nothing happens.  It's body is expanded here, and its epilogue pops a
  1035. # diversion.
  1036. #   DUMP:       BODY
  1037. #   BODY:       TEST2a
  1038. #   GROW - 2:   TEST3
  1039. #   diversions: GROW - 2, GROW - 1, GROW - 1, GROW, BODY |-
  1040. #
  1041. # * TEST2b requires TEST3: epilogue
  1042. # The current diversion is appended to DUMP, and a diversion is popped.
  1043. #   DUMP:       BODY
  1044. #   BODY:       TEST2a; TEST3
  1045. #   diversions: GROW - 1, GROW - 1, GROW, BODY |-
  1046. # The content of TEST2b is expanded here.
  1047. #   DUMP:       BODY
  1048. #   BODY:       TEST2a; TEST3
  1049. #   GROW - 1:   TEST2b,
  1050. #   diversions: GROW - 1, GROW - 1, GROW, BODY |-
  1051. # The epilogue of TEST2b pops a diversion.
  1052. #   DUMP:       BODY
  1053. #   BODY:       TEST2a; TEST3
  1054. #   GROW - 1:   TEST2b,
  1055. #   diversions: GROW - 1, GROW, BODY |-
  1056. #
  1057. # * TEST1 requires TEST2b: epilogue
  1058. # The current diversion is appended to DUMP, and a diversion is popped.
  1059. #   DUMP:       BODY
  1060. #   BODY:       TEST2a; TEST3; TEST2b
  1061. #   diversions: GROW, BODY |-
  1062. #
  1063. # * TEST1 is expanded: epilogue
  1064. # TEST1's own content is in GROW, and it's epilogue pops a diversion.
  1065. #   DUMP:       BODY
  1066. #   BODY:       TEST2a; TEST3; TEST2b
  1067. #   GROW:       TEST1
  1068. #   diversions: BODY |-
  1069. # Here, the epilogue of TEST1 notices the elaboration is done because
  1070. # DUMP and the current diversion are the same, it then undiverts
  1071. # GROW by hand, and undefines DUMP.
  1072. #   DUMP:       undefined
  1073. #   BODY:       TEST2a; TEST3; TEST2b; TEST1
  1074. #   diversions: BODY |-
  1075. #
  1076. #
  1077. # 2. Keeping track of the expansion stack
  1078. # =======================================
  1079. #
  1080. # When M4 expansion goes wrong it is often extremely hard to find the
  1081. # path amongst macros that drove to the failure.  What is needed is
  1082. # the stack of macro `calls'. One could imagine that GNU M4 would
  1083. # maintain a stack of macro expansions, unfortunately it doesn't, so
  1084. # we do it by hand.  This is of course extremely costly, but the help
  1085. # this stack provides is worth it.  Nevertheless to limit the
  1086. # performance penalty this is implemented only for m4_defun'd macros,
  1087. # not for define'd macros.
  1088. #
  1089. # The scheme is simplistic: each time we enter an m4_defun'd macros,
  1090. # we prepend its name in m4_expansion_stack, and when we exit the
  1091. # macro, we remove it (thanks to pushdef/popdef).
  1092. #
  1093. # In addition, we want to use the expansion stack to detect circular
  1094. # m4_require dependencies.  This means we need to browse the stack to
  1095. # check whether a macro being expanded is m4_require'd.  For ease of
  1096. # implementation, and certainly for the benefit of performances, we
  1097. # don't browse the m4_expansion_stack, rather each time we expand a
  1098. # macro FOO we define _m4_expanding(FOO).  Then m4_require(BAR) simply
  1099. # needs to check whether _m4_expanding(BAR) is defined to diagnose a
  1100. # circular dependency.
  1101. #
  1102. # To improve the diagnostic, in addition to keeping track of the stack
  1103. # of macro calls, m4_expansion_stack also records the m4_require
  1104. # stack.  Note that therefore an m4_defun'd macro being required will
  1105. # appear twice in the stack: the first time because it is required,
  1106. # the second because it is expanded.  We can avoid this, but it has
  1107. # two small drawbacks: (i) the implementation is slightly more
  1108. # complex, and (ii) it hides the difference between define'd macros
  1109. # (which don't appear in m4_expansion_stack) and m4_defun'd macros
  1110. # (which do).  The more debugging information, the better.
  1111.  
  1112.  
  1113. # m4_expansion_stack_push(TEXT)
  1114. # -----------------------------
  1115. m4_define([m4_expansion_stack_push],
  1116. [m4_pushdef([m4_expansion_stack],
  1117.         [$1]m4_ifdef([m4_expansion_stack], [
  1118. m4_defn([m4_expansion_stack])]))])
  1119.  
  1120.  
  1121. # m4_expansion_stack_pop
  1122. # ----------------------
  1123. # Dump the expansion stack.
  1124. m4_define([m4_expansion_stack_pop],
  1125. [m4_popdef([m4_expansion_stack])])
  1126.  
  1127.  
  1128. # m4_expansion_stack_dump
  1129. # -----------------------
  1130. # Dump the expansion stack.
  1131. m4_define([m4_expansion_stack_dump],
  1132. [m4_ifdef([m4_expansion_stack],
  1133.       [m4_errprintn(m4_defn([m4_expansion_stack]))])dnl
  1134. m4_errprintn(m4_location[: the top level])])
  1135.  
  1136.  
  1137. # _m4_divert(GROW)
  1138. # ----------------
  1139. # This diversion is used by the m4_defun/m4_require machinery.  It is
  1140. # important to keep room before GROW because for each nested
  1141. # AC_REQUIRE we use an additional diversion (i.e., two m4_require's
  1142. # will use GROW - 2.  More than 3 levels has never seemed to be
  1143. # needed.)
  1144. #
  1145. # ...
  1146. # - GROW - 2
  1147. #   m4_require'd code, 2 level deep
  1148. # - GROW - 1
  1149. #   m4_require'd code, 1 level deep
  1150. # - GROW
  1151. #   m4_defun'd macros are elaborated here.
  1152.  
  1153. m4_define([_m4_divert(GROW)],       10000)
  1154.  
  1155.  
  1156. # _m4_defun_pro(MACRO-NAME)
  1157. # -------------------------
  1158. # The prologue for Autoconf macros.
  1159. m4_define([_m4_defun_pro],
  1160. [m4_expansion_stack_push(m4_defn([m4_location($1)])[: $1 is expanded from...])dnl
  1161. m4_pushdef([_m4_expanding($1)])dnl
  1162. m4_ifdef([_m4_divert_dump],
  1163.      [m4_divert_push(m4_defn([_m4_divert_diversion]))],
  1164.      [m4_copy([_m4_divert_diversion], [_m4_divert_dump])dnl
  1165. m4_divert_push([GROW])])dnl
  1166. ])
  1167.  
  1168.  
  1169. # _m4_defun_epi(MACRO-NAME)
  1170. # -------------------------
  1171. # The Epilogue for Autoconf macros.  MACRO-NAME only helps tracing
  1172. # the PRO/EPI pairs.
  1173. m4_define([_m4_defun_epi],
  1174. [m4_divert_pop()dnl
  1175. m4_if(_m4_divert_dump, _m4_divert_diversion,
  1176.       [m4_undivert([GROW])dnl
  1177. m4_undefine([_m4_divert_dump])])dnl
  1178. m4_expansion_stack_pop()dnl
  1179. m4_popdef([_m4_expanding($1)])dnl
  1180. m4_provide([$1])dnl
  1181. ])
  1182.  
  1183.  
  1184. # m4_defun(NAME, EXPANSION)
  1185. # -------------------------
  1186. # Define a macro which automatically provides itself.  Add machinery
  1187. # so the macro automatically switches expansion to the diversion
  1188. # stack if it is not already using it.  In this case, once finished,
  1189. # it will bring back all the code accumulated in the diversion stack.
  1190. # This, combined with m4_require, achieves the topological ordering of
  1191. # macros.  We don't use this macro to define some frequently called
  1192. # macros that are not involved in ordering constraints, to save m4
  1193. # processing.
  1194. m4_define([m4_defun],
  1195. [m4_define([m4_location($1)], m4_location)dnl
  1196. m4_define([$1],
  1197.       [_m4_defun_pro([$1])$2[]_m4_defun_epi([$1])])])
  1198.  
  1199.  
  1200. # m4_defun_once(NAME, EXPANSION)
  1201. # ------------------------------
  1202. # As m4_defun, but issues the EXPANSION only once, and warns if used
  1203. # several times.
  1204. m4_define([m4_defun_once],
  1205. [m4_define([m4_location($1)], m4_location)dnl
  1206. m4_define([$1],
  1207.       [m4_provide_if([$1],
  1208.              [m4_warn([syntax], [$1 invoked multiple times])],
  1209.              [_m4_defun_pro([$1])$2[]_m4_defun_epi([$1])])])])
  1210.  
  1211.  
  1212. # m4_pattern_forbid(ERE, [WHY])
  1213. # -----------------------------
  1214. # Declare that no token matching the extended regular expression ERE
  1215. # should be seen in the output but if...
  1216. m4_define([m4_pattern_forbid], [])
  1217.  
  1218.  
  1219. # m4_pattern_allow(ERE)
  1220. # ---------------------
  1221. # ... but if that token matches the extended regular expression ERE.
  1222. # Both used via traces.
  1223. m4_define([m4_pattern_allow], [])
  1224.  
  1225.  
  1226. ## ----------------------------- ##
  1227. ## Dependencies between macros.  ##
  1228. ## ----------------------------- ##
  1229.  
  1230.  
  1231. # m4_before(THIS-MACRO-NAME, CALLED-MACRO-NAME)
  1232. # ---------------------------------------------
  1233. m4_define([m4_before],
  1234. [m4_provide_if([$2],
  1235.            [m4_warn([syntax], [$2 was called before $1])])])
  1236.  
  1237.  
  1238. # m4_require(NAME-TO-CHECK, [BODY-TO-EXPAND = NAME-TO-CHECK])
  1239. # -----------------------------------------------------------
  1240. # If NAME-TO-CHECK has never been expanded (actually, if it is not
  1241. # m4_provide'd), expand BODY-TO-EXPAND *before* the current macro
  1242. # expansion.  Once expanded, emit it in _m4_divert_dump.  Keep track
  1243. # of the m4_require chain in m4_expansion_stack.
  1244. #
  1245. # The normal cases are:
  1246. #
  1247. # - NAME-TO-CHECK == BODY-TO-EXPAND
  1248. #   Which you can use for regular macros with or without arguments, e.g.,
  1249. #     m4_require([AC_PROG_CC], [AC_PROG_CC])
  1250. #     m4_require([AC_CHECK_HEADERS(limits.h)], [AC_CHECK_HEADERS(limits.h)])
  1251. #   which is just the same as
  1252. #     m4_require([AC_PROG_CC])
  1253. #     m4_require([AC_CHECK_HEADERS(limits.h)])
  1254. #
  1255. # - BODY-TO-EXPAND == m4_indir([NAME-TO-CHECK])
  1256. #   In the case of macros with irregular names.  For instance:
  1257. #     m4_require([AC_LANG_COMPILER(C)], [indir([AC_LANG_COMPILER(C)])])
  1258. #   which means `if the macro named `AC_LANG_COMPILER(C)' (the parens are
  1259. #   part of the name, it is not an argument) has not been run, then
  1260. #   call it.'
  1261. #   Had you used
  1262. #     m4_require([AC_LANG_COMPILER(C)], [AC_LANG_COMPILER(C)])
  1263. #   then m4_require would have tried to expand `AC_LANG_COMPILER(C)', i.e.,
  1264. #   call the macro `AC_LANG_COMPILER' with `C' as argument.
  1265. #
  1266. #   You could argue that `AC_LANG_COMPILER', when it receives an argument
  1267. #   such as `C' should dispatch the call to `AC_LANG_COMPILER(C)'.  But this
  1268. #   `extension' prevents `AC_LANG_COMPILER' from having actual arguments that
  1269. #   it passes to `AC_LANG_COMPILER(C)'.
  1270. m4_define([m4_require],
  1271. [m4_expansion_stack_push(m4_location[: $1 is required by...])dnl
  1272. m4_ifdef([_m4_expanding($1)],
  1273.      [m4_fatal([$0: circular dependency of $1])])dnl
  1274. m4_ifndef([_m4_divert_dump],
  1275.       [m4_fatal([$0: cannot be used outside of an m4_defun'd macro])])dnl
  1276. m4_provide_if([$1],
  1277.           [],
  1278.           [m4_divert_push(m4_eval(m4_divnum - 1))dnl
  1279. m4_default([$2], [$1])
  1280. m4_divert(m4_defn([_m4_divert_dump]))dnl
  1281. m4_undivert(m4_defn([_m4_divert_diversion]))dnl
  1282. m4_divert_pop(m4_defn([_m4_divert_dump]))])dnl
  1283. m4_provide_if([$1],
  1284.           [],
  1285.           [m4_warn([syntax],
  1286.                [$1 is m4_require'd but is not m4_defun'd])])dnl
  1287. m4_expansion_stack_pop()dnl
  1288. ])
  1289.  
  1290.  
  1291. # m4_expand_once(TEXT, [WITNESS = TEXT])
  1292. # --------------------------------------
  1293. # If TEXT has never been expanded, expand it *here*.  Use WITNESS as
  1294. # as a memory that TEXT has already been expanded.
  1295. m4_define([m4_expand_once],
  1296. [m4_provide_if(m4_ifval([$2], [[$2]], [[$1]]),
  1297.            [],
  1298.            [m4_provide(m4_ifval([$2], [[$2]], [[$1]]))[]$1])])
  1299.  
  1300.  
  1301. # m4_provide(MACRO-NAME)
  1302. # ----------------------
  1303. m4_define([m4_provide],
  1304. [m4_define([m4_provide($1)])])
  1305.  
  1306.  
  1307. # m4_provide_if(MACRO-NAME, IF-PROVIDED, IF-NOT-PROVIDED)
  1308. # -------------------------------------------------------
  1309. # If MACRO-NAME is provided do IF-PROVIDED, else IF-NOT-PROVIDED.
  1310. # The purpose of this macro is to provide the user with a means to
  1311. # check macros which are provided without letting her know how the
  1312. # information is coded.
  1313. m4_define([m4_provide_if],
  1314. [m4_ifdef([m4_provide($1)],
  1315.       [$2], [$3])])
  1316.  
  1317.  
  1318. ## -------------------- ##
  1319. ## 9. Text processing.  ##
  1320. ## -------------------- ##
  1321.  
  1322.  
  1323. # m4_cr_letters
  1324. # m4_cr_LETTERS
  1325. # m4_cr_Letters
  1326. # -------------
  1327. m4_define([m4_cr_letters], [abcdefghijklmnopqrstuvwxyz])
  1328. m4_define([m4_cr_LETTERS], [ABCDEFGHIJKLMNOPQRSTUVWXYZ])
  1329. m4_define([m4_cr_Letters],
  1330. m4_defn([m4_cr_letters])dnl
  1331. m4_defn([m4_cr_LETTERS])dnl
  1332. )
  1333.  
  1334.  
  1335. # m4_cr_digits
  1336. # ------------
  1337. m4_define([m4_cr_digits], [0123456789])
  1338.  
  1339.  
  1340. # m4_cr_symbols1 & m4_cr_symbols2
  1341. # -------------------------------
  1342. m4_define([m4_cr_symbols1],
  1343. m4_defn([m4_cr_Letters])dnl
  1344. _)
  1345.  
  1346. m4_define([m4_cr_symbols2],
  1347. m4_defn([m4_cr_symbols1])dnl
  1348. m4_defn([m4_cr_digits])dnl
  1349. )
  1350.  
  1351.  
  1352. # m4_re_escape(STRING)
  1353. # --------------------
  1354. # Escape BRE active characters in STRING.
  1355. m4_define([m4_re_escape],
  1356. [m4_bpatsubst([$1],
  1357.           [[][+*.]], [\\\&])])
  1358.  
  1359.  
  1360. # m4_re_string
  1361. # ------------
  1362. # Regexp for `[a-zA-Z_0-9]*'
  1363. m4_define([m4_re_string],
  1364. m4_defn([m4_cr_symbols2])dnl
  1365. [*]dnl
  1366. )
  1367.  
  1368.  
  1369. # m4_re_word
  1370. # ----------
  1371. # Regexp for `[a-zA-Z_][a-zA-Z_0-9]*'
  1372. m4_define([m4_re_word],
  1373. m4_defn([m4_cr_symbols1])dnl
  1374. m4_defn([m4_re_string])dnl
  1375. )
  1376.  
  1377.  
  1378. # m4_tolower(STRING)
  1379. # m4_toupper(STRING)
  1380. # ------------------
  1381. # These macros lowercase and uppercase strings.
  1382. m4_define([m4_tolower],
  1383. [m4_translit([$1], m4_defn([m4_cr_LETTERS]), m4_defn([m4_cr_letters]))])
  1384. m4_define([m4_toupper],
  1385. [m4_translit([$1], m4_defn([m4_cr_letters]), m4_defn([m4_cr_LETTERS]))])
  1386.  
  1387.  
  1388. # m4_split(STRING, [REGEXP])
  1389. # --------------------------
  1390. #
  1391. # Split STRING into an m4 list of quoted elements.  The elements are
  1392. # quoted with [ and ].  Beginning spaces and end spaces *are kept*.
  1393. # Use m4_strip to remove them.
  1394. #
  1395. # REGEXP specifies where to split.  Default is [\t ]+.
  1396. #
  1397. # Pay attention to the m4_changequotes.  Inner m4_changequotes exist for
  1398. # obvious reasons (we want to insert square brackets).  Outer
  1399. # m4_changequotes are needed because otherwise the m4 parser, when it
  1400. # sees the closing bracket we add to the result, believes it is the
  1401. # end of the body of the macro we define.
  1402. #
  1403. # Also, notice that $1 is quoted twice, since we want the result to
  1404. # be quoted.  Then you should understand that the argument of
  1405. # patsubst is ``STRING'' (i.e., with additional `` and '').
  1406. #
  1407. # This macro is safe on active symbols, i.e.:
  1408. #   m4_define(active, ACTIVE)
  1409. #   m4_split([active active ])end
  1410. #   => [active], [active], []end
  1411.  
  1412. m4_changequote(<<, >>)
  1413. m4_define(<<m4_split>>,
  1414. <<m4_changequote(``, '')dnl
  1415. [dnl Can't use m4_default here instead of m4_if, because m4_default uses
  1416. dnl [ and ] as quotes.
  1417. m4_bpatsubst(````$1'''',
  1418.          m4_if(``$2'',, ``[     ]+'', ``$2''),
  1419.          ``], ['')]dnl
  1420. m4_changequote([, ])>>)
  1421. m4_changequote([, ])
  1422.  
  1423.  
  1424.  
  1425. # m4_flatten(STRING)
  1426. # ------------------
  1427. # If STRING contains end of lines, replace them with spaces.  If there
  1428. # are backslashed end of lines, remove them.  This macro is safe with
  1429. # active symbols.
  1430. #    m4_define(active, ACTIVE)
  1431. #    m4_flatten([active
  1432. #    act\
  1433. #    ive])end
  1434. #    => active activeend
  1435. m4_define([m4_flatten],
  1436. [m4_translit(m4_bpatsubst([[[$1]]], [\\
  1437. ]), [
  1438. ], [ ])])
  1439.  
  1440.  
  1441. # m4_strip(STRING)
  1442. # ----------------
  1443. # Expands into STRING with tabs and spaces singled out into a single
  1444. # space, and removing leading and trailing spaces.
  1445. #
  1446. # This macro is robust to active symbols.
  1447. #    m4_define(active, ACTIVE)
  1448. #    m4_strip([  active          active ])end
  1449. #    => active activeend
  1450. #
  1451. # This macro is fun!  Because we want to preserve active symbols, STRING
  1452. # must be quoted for each evaluation, which explains there are 4 levels
  1453. # of brackets around $1 (don't forget that the result must be quoted
  1454. # too, hence one more quoting than applications).
  1455. #
  1456. # Then notice the 2 last patterns: they are in charge of removing the
  1457. # leading/trailing spaces.  Why not just `[^ ]'?  Because they are
  1458. # applied to doubly quoted strings, i.e. more or less [[STRING]].  So
  1459. # if there is a leading space in STRING, then it is the *third*
  1460. # character, since there are two leading `['; equally for the last pattern.
  1461. m4_define([m4_strip],
  1462. [m4_bpatsubsts([[$1]],
  1463.            [[     ]+], [ ],
  1464.            [^\(..\) ],    [\1],
  1465.            [ \(..\)$],    [\1])])
  1466.  
  1467.  
  1468. # m4_normalize(STRING)
  1469. # --------------------
  1470. # Apply m4_flatten and m4_strip to STRING.
  1471. #
  1472. # The argument is quoted, so that the macro is robust to active symbols:
  1473. #
  1474. #    m4_define(active, ACTIVE)
  1475. #    m4_normalize([  act\
  1476. #    ive
  1477. #    active ])end
  1478. #    => active activeend
  1479.  
  1480. m4_define([m4_normalize],
  1481. [m4_strip(m4_flatten([$1]))])
  1482.  
  1483.  
  1484.  
  1485. # m4_join(SEP, ARG1, ARG2...)
  1486. # ---------------------------
  1487. # Produce ARG1SEPARG2...SEPARGn.
  1488. m4_defun([m4_join],
  1489. [m4_case([$#],
  1490.      [1], [],
  1491.      [2], [[$2]],
  1492.      [[$2][$1]$0([$1], m4_shiftn(2, $@))])])
  1493.  
  1494.  
  1495.  
  1496. # m4_append(MACRO-NAME, STRING, [SEPARATOR])
  1497. # ------------------------------------------
  1498. # Redefine MACRO-NAME to hold its former content plus `SEPARATOR`'STRING'
  1499. # at the end.  It is valid to use this macro with MACRO-NAME undefined,
  1500. # in which case no SEPARATOR is added.  Be aware that the criterion is
  1501. # `not being defined', and not `not being empty'.
  1502. #
  1503. # This macro is robust to active symbols.  It can be used to grow
  1504. # strings.
  1505. #
  1506. #    | m4_define(active, ACTIVE)
  1507. #    | m4_append([sentence], [This is an])
  1508. #    | m4_append([sentence], [ active ])
  1509. #    | m4_append([sentence], [symbol.])
  1510. #    | sentence
  1511. #    | m4_undefine([active])dnl
  1512. #    | sentence
  1513. #    => This is an ACTIVE symbol.
  1514. #    => This is an active symbol.
  1515. #
  1516. # It can be used to define hooks.
  1517. #
  1518. #    | m4_define(active, ACTIVE)
  1519. #    | m4_append([hooks], [m4_define([act1], [act2])])
  1520. #    | m4_append([hooks], [m4_define([act2], [active])])
  1521. #    | m4_undefine([active])
  1522. #    | act1
  1523. #    | hooks
  1524. #    | act1
  1525. #    => act1
  1526. #    =>
  1527. #    => active
  1528. m4_define([m4_append],
  1529. [m4_define([$1],
  1530.        m4_ifdef([$1], [m4_defn([$1])$3])[$2])])
  1531.  
  1532.  
  1533. # m4_append_uniq(MACRO-NAME, STRING, [SEPARATOR])
  1534. # -----------------------------------------------
  1535. # As `m4_append', but append only if not yet present.
  1536. m4_define([m4_append_uniq],
  1537. [m4_ifdef([$1],
  1538.       [m4_bmatch([$3]m4_defn([$1])[$3], m4_re_escape([$3$2$3]), [],
  1539.              [m4_append($@)])],
  1540.       [m4_append($@)])])
  1541.  
  1542.  
  1543. # m4_text_wrap(STRING, [PREFIX], [FIRST-PREFIX], [WIDTH])
  1544. # -------------------------------------------------------
  1545. # Expands into STRING wrapped to hold in WIDTH columns (default = 79).
  1546. # If prefix is set, each line is prefixed with it.  If FIRST-PREFIX is
  1547. # specified, then the first line is prefixed with it.  As a special
  1548. # case, if the length of the first prefix is greater than that of
  1549. # PREFIX, then FIRST-PREFIX will be left alone on the first line.
  1550. #
  1551. # Typical outputs are:
  1552. #
  1553. # m4_text_wrap([Short string */], [   ], [/* ], 20)
  1554. #  => /* Short string */
  1555. #
  1556. # m4_text_wrap([Much longer string */], [   ], [/* ], 20)
  1557. #  => /* Much longer
  1558. #  =>    string */
  1559. #
  1560. # m4_text_wrap([Short doc.], [          ], [  --short ], 30)
  1561. #  =>   --short Short doc.
  1562. #
  1563. # m4_text_wrap([Short doc.], [          ], [  --too-wide ], 30)
  1564. #  =>   --too-wide
  1565. #  =>           Short doc.
  1566. #
  1567. # m4_text_wrap([Super long documentation.], [          ], [  --too-wide ], 30)
  1568. #  =>   --too-wide
  1569. #  =>      Super long
  1570. #  =>      documentation.
  1571. #
  1572. # FIXME: there is no checking of a longer PREFIX than WIDTH, but do
  1573. # we really want to bother with people trying each single corner
  1574. # of a software?
  1575. #
  1576. # This macro does not leave a trailing space behind the last word,
  1577. # what complicates it a bit.  The algorithm is stupid simple: all the
  1578. # words are preceded by m4_Separator which is defined to empty for the
  1579. # first word, and then ` ' (single space) for all the others.
  1580. m4_define([m4_text_wrap],
  1581. [m4_pushdef([m4_Prefix], m4_default([$2], []))dnl
  1582. m4_pushdef([m4_Prefix1], m4_default([$3], [m4_Prefix]))dnl
  1583. m4_pushdef([m4_Width], m4_default([$4], 79))dnl
  1584. m4_pushdef([m4_Cursor], m4_len(m4_Prefix1))dnl
  1585. m4_pushdef([m4_Separator], [])dnl
  1586. m4_Prefix1[]dnl
  1587. m4_if(m4_eval(m4_Cursor > m4_len(m4_Prefix)),
  1588.       1, [m4_define([m4_Cursor], m4_len(m4_Prefix))
  1589. m4_Prefix])[]dnl
  1590. m4_foreach([m4_Word], m4_quote(m4_split(m4_normalize([$1]))),
  1591. [m4_define([m4_Cursor], m4_eval(m4_Cursor + m4_len(m4_defn([m4_Word])) + 1))dnl
  1592. dnl New line if too long, else insert a space unless it is the first
  1593. dnl of the words.
  1594. m4_if(m4_eval(m4_Cursor > m4_Width),
  1595.       1, [m4_define([m4_Cursor],
  1596.             m4_eval(m4_len(m4_Prefix) + m4_len(m4_defn([m4_Word])) + 1))]
  1597. m4_Prefix,
  1598.        [m4_Separator])[]dnl
  1599. m4_defn([m4_Word])[]dnl
  1600. m4_define([m4_Separator], [ ])])dnl
  1601. m4_popdef([m4_Separator])dnl
  1602. m4_popdef([m4_Cursor])dnl
  1603. m4_popdef([m4_Width])dnl
  1604. m4_popdef([m4_Prefix1])dnl
  1605. m4_popdef([m4_Prefix])dnl
  1606. ])
  1607.  
  1608.  
  1609. # m4_text_box(MESSAGE, [FRAME-CHARACTER = `-'])
  1610. # ---------------------------------------------
  1611. m4_define([m4_text_box],
  1612. [@%:@@%:@ m4_bpatsubst([$1], [.], m4_if([$2], [], [[-]], [[$2]])) @%:@@%:@
  1613. @%:@@%:@ $1 @%:@@%:@
  1614. @%:@@%:@ m4_bpatsubst([$1], [.], m4_if([$2], [], [[-]], [[$2]])) @%:@@%:@[]dnl
  1615. ])
  1616.  
  1617.  
  1618.  
  1619. ## ----------------------- ##
  1620. ## 10. Number processing.  ##
  1621. ## ----------------------- ##
  1622.  
  1623. # m4_sign(A)
  1624. # ----------
  1625. #
  1626. # The sign of the integer A.
  1627. m4_define([m4_sign],
  1628. [m4_bmatch([$1],
  1629.        [^-], -1,
  1630.        [^0+], 0,
  1631.           1)])
  1632.  
  1633. # m4_cmp(A, B)
  1634. # ------------
  1635. #
  1636. # Compare two integers.
  1637. # A < B -> -1
  1638. # A = B ->  0
  1639. # A > B ->  1
  1640. m4_define([m4_cmp],
  1641. [m4_sign(m4_eval([$1 - $2]))])
  1642.  
  1643.  
  1644. # m4_list_cmp(A, B)
  1645. # -----------------
  1646. #
  1647. # Compare the two lists of integers A and B.  For instance:
  1648. #   m4_list_cmp((1, 0),     (1))    ->  0
  1649. #   m4_list_cmp((1, 0),     (1, 0)) ->  0
  1650. #   m4_list_cmp((1, 2),     (1, 0)) ->  1
  1651. #   m4_list_cmp((1, 2, 3),  (1, 2)) ->  1
  1652. #   m4_list_cmp((1, 2, -3), (1, 2)) -> -1
  1653. #   m4_list_cmp((1, 0),     (1, 2)) -> -1
  1654. #   m4_list_cmp((1),        (1, 2)) -> -1
  1655. m4_define([m4_list_cmp],
  1656. [m4_if([$1$2], [()()], 0,
  1657.        [$1], [()], [$0((0), [$2])],
  1658.        [$2], [()], [$0([$1], (0))],
  1659.        [m4_case(m4_cmp(m4_car$1, m4_car$2),
  1660.         -1, -1,
  1661.          1, 1,
  1662.          0, [$0((m4_shift$1), (m4_shift$2))])])])
  1663.  
  1664.  
  1665.  
  1666. ## ------------------------ ##
  1667. ## 11. Version processing.  ##
  1668. ## ------------------------ ##
  1669.  
  1670.  
  1671. # m4_version_unletter(VERSION)
  1672. # ----------------------------
  1673. # Normalize beta version numbers with letters to numbers only for comparison.
  1674. #
  1675. #   Nl -> (N+1).-1.(l#)
  1676. #
  1677. #i.e., 2.14a -> 2.15.-1.1, 2.14b -> 2.15.-1.2, etc.
  1678. # This macro is absolutely not robust to active macro, it expects
  1679. # reasonable version numbers and is valid up to `z', no double letters.
  1680. m4_define([m4_version_unletter],
  1681. [m4_translit(m4_bpatsubsts([$1],
  1682.                [\([0-9]+\)\([abcdefghi]\)],
  1683.                  [m4_eval(\1 + 1).-1.\2],
  1684.                [\([0-9]+\)\([jklmnopqrs]\)],
  1685.                  [m4_eval(\1 + 1).-1.1\2],
  1686.                [\([0-9]+\)\([tuvwxyz]\)],
  1687.                  [m4_eval(\1 + 1).-1.2\2]),
  1688.          [abcdefghijklmnopqrstuvwxyz],
  1689.          [12345678901234567890123456])])
  1690.  
  1691.  
  1692. # m4_version_compare(VERSION-1, VERSION-2)
  1693. # ----------------------------------------
  1694. # Compare the two version numbers and expand into
  1695. #  -1 if VERSION-1 < VERSION-2
  1696. #   0 if           =
  1697. #   1 if           >
  1698. m4_define([m4_version_compare],
  1699. [m4_list_cmp((m4_split(m4_version_unletter([$1]), [\.])),
  1700.          (m4_split(m4_version_unletter([$2]), [\.])))])
  1701.  
  1702.  
  1703. # m4_PACKAGE_NAME
  1704. # m4_PACKAGE_TARNAME
  1705. # m4_PACKAGE_VERSION
  1706. # m4_PACKAGE_STRING
  1707. # m4_PACKAGE_BUGREPORT
  1708. # --------------------
  1709. m4_include([m4sugar/version.m4])
  1710.  
  1711.  
  1712. # m4_version_prereq(VERSION, [IF-OK], [IF-NOT = FAIL])
  1713. # ----------------------------------------------------
  1714. # Check this Autoconf version against VERSION.
  1715. m4_define([m4_version_prereq],
  1716. [m4_if(m4_version_compare(m4_defn([m4_PACKAGE_VERSION]), [$1]), -1,
  1717.        [m4_default([$3],
  1718.            [m4_fatal([Autoconf version $1 or higher is required],
  1719.                  63)])],
  1720.        [$2])[]dnl
  1721. ])
  1722.  
  1723.  
  1724.  
  1725. ## ------------------- ##
  1726. ## 12. File handling.  ##
  1727. ## ------------------- ##
  1728.  
  1729.  
  1730. # It is a real pity that M4 comes with no macros to bind a diversion
  1731. # to a file.  So we have to deal without, which makes us a lot more
  1732. # fragile that we should.
  1733.  
  1734.  
  1735. # m4_file_append(FILE-NAME, CONTENT)
  1736. # ----------------------------------
  1737. m4_define([m4_file_append],
  1738. [m4_syscmd([cat >>$1 <<_m4eof
  1739. $2
  1740. _m4eof
  1741. ])
  1742. m4_if(m4_sysval, [0], [],
  1743.       [m4_fatal([$0: cannot write: $1])])])
  1744.  
  1745.  
  1746.  
  1747. ## ------------------------ ##
  1748. ## 13. Setting M4sugar up.  ##
  1749. ## ------------------------ ##
  1750.  
  1751.  
  1752. # m4_init
  1753. # -------
  1754. m4_define([m4_init],
  1755. [# All the M4sugar macros start with `m4_', except `dnl' kept as is
  1756. # for sake of simplicity.
  1757. m4_pattern_forbid([^_?m4_])
  1758. m4_pattern_forbid([^dnl$])
  1759.  
  1760. # Check the divert push/pop perfect balance.
  1761. m4_wrap([m4_ifdef([_m4_divert_diversion],
  1762.           [m4_fatal([$0: unbalanced m4_divert_push:]
  1763. m4_defn([m4_divert_stack]))])[]])
  1764.  
  1765. m4_divert_push([KILL])
  1766. m4_wrap([m4_divert_pop([KILL])[]])
  1767. ])
  1768.